/**
 * 格式化工具函数
 */

/**
 * 格式化日期时间
 * @param dateTime 日期时间字符串或Date对象
 * @param format 格式化模式，默认为 'YYYY-MM-DD HH:mm:ss'
 * @returns 格式化后的日期时间字符串
 */
export function formatDateTime(dateTime: string | Date | null | undefined, format: string = 'YYYY-MM-DD HH:mm:ss'): string {
  if (!dateTime) {
    return '-'
  }
  
  try {
    const date = typeof dateTime === 'string' ? new Date(dateTime) : dateTime
    
    if (isNaN(date.getTime())) {
      return '-'
    }
    
    const year = date.getFullYear()
    const month = String(date.getMonth() + 1).padStart(2, '0')
    const day = String(date.getDate()).padStart(2, '0')
    const hours = String(date.getHours()).padStart(2, '0')
    const minutes = String(date.getMinutes()).padStart(2, '0')
    const seconds = String(date.getSeconds()).padStart(2, '0')
    
    return format
      .replace('YYYY', String(year))
      .replace('MM', month)
      .replace('DD', day)
      .replace('HH', hours)
      .replace('mm', minutes)
      .replace('ss', seconds)
  } catch (error) {
    return '-'
  }
}

/**
 * 格式化日期
 * @param date 日期字符串或Date对象
 * @returns 格式化后的日期字符串 YYYY-MM-DD
 */
export function formatDate(date: string | Date | null | undefined): string {
  return formatDateTime(date, 'YYYY-MM-DD')
}

/**
 * 格式化时间
 * @param time 时间字符串或Date对象
 * @returns 格式化后的时间字符串 HH:mm:ss
 */
export function formatTime(time: string | Date | null | undefined): string {
  return formatDateTime(time, 'YYYY-MM-DD HH:mm:ss')
}

/**
 * 格式化相对时间
 * @param dateTime 日期时间字符串或Date对象
 * @returns 相对时间字符串，如"刚刚"、"5分钟前"、"2小时前"等
 */
export function formatRelativeTime(dateTime: string | Date | null | undefined): string {
  if (!dateTime) {
    return '-'
  }
  
  try {
    const date = typeof dateTime === 'string' ? new Date(dateTime) : dateTime
    const now = new Date()
    const diff = now.getTime() - date.getTime()
    
    if (diff < 0) {
      return '未来时间'
    }
    
    const seconds = Math.floor(diff / 1000)
    const minutes = Math.floor(seconds / 60)
    const hours = Math.floor(minutes / 60)
    const days = Math.floor(hours / 24)
    const months = Math.floor(days / 30)
    const years = Math.floor(days / 365)
    
    if (seconds < 60) {
      return '刚刚'
    } else if (minutes < 60) {
      return `${minutes}分钟前`
    } else if (hours < 24) {
      return `${hours}小时前`
    } else if (days < 30) {
      return `${days}天前`
    } else if (months < 12) {
      return `${months}个月前`
    } else {
      return `${years}年前`
    }
  } catch (error) {
    return '-'
  }
}

/**
 * 格式化文件大小
 * @param bytes 字节数
 * @returns 格式化后的文件大小字符串
 */
export function formatFileSize(bytes: number | null | undefined): string {
  if (!bytes || bytes === 0) {
    return '0 B'
  }
  
  const units = ['B', 'KB', 'MB', 'GB', 'TB']
  const k = 1024
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  
  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${units[i]}`
}

/**
 * 格式化数字
 * @param num 数字
 * @param decimals 小数位数，默认为2
 * @returns 格式化后的数字字符串
 */
export function formatNumber(num: number | null | undefined, decimals: number = 2): string {
  if (num === null || num === undefined || isNaN(num)) {
    return '0'
  }
  
  return num.toLocaleString('zh-CN', {
    minimumFractionDigits: decimals,
    maximumFractionDigits: decimals
  })
}

/**
 * 格式化百分比
 * @param value 数值
 * @param total 总数
 * @param decimals 小数位数，默认为1
 * @returns 格式化后的百分比字符串
 */
export function formatPercentage(value: number, total: number, decimals: number = 1): string {
  if (!total || total === 0) {
    return '0%'
  }
  
  const percentage = (value / total) * 100
  return `${percentage.toFixed(decimals)}%`
}

/**
 * 格式化货币
 * @param amount 金额
 * @param currency 货币符号，默认为'¥'
 * @returns 格式化后的货币字符串
 */
export function formatCurrency(amount: number | null | undefined, currency: string = '¥'): string {
  if (amount === null || amount === undefined || isNaN(amount)) {
    return `${currency}0.00`
  }
  
  return `${currency}${amount.toLocaleString('zh-CN', {
    minimumFractionDigits: 2,
    maximumFractionDigits: 2
  })}`
}

/**
 * 格式化手机号
 * @param phone 手机号
 * @returns 格式化后的手机号，中间4位用*替代
 */
export function formatPhone(phone: string | null | undefined): string {
  if (!phone) {
    return '-'
  }
  
  if (phone.length === 11) {
    return `${phone.slice(0, 3)}****${phone.slice(7)}`
  }
  
  return phone
}

/**
 * 格式化身份证号
 * @param idCard 身份证号
 * @returns 格式化后的身份证号，中间部分用*替代
 */
export function formatIdCard(idCard: string | null | undefined): string {
  if (!idCard) {
    return '-'
  }
  
  if (idCard.length === 18) {
    return `${idCard.slice(0, 6)}********${idCard.slice(14)}`
  }
  
  return idCard
}

/**
 * 格式化邮箱
 * @param email 邮箱
 * @returns 格式化后的邮箱，用户名部分用*替代
 */
export function formatEmail(email: string | null | undefined): string {
  if (!email) {
    return '-'
  }
  
  const atIndex = email.indexOf('@')
  if (atIndex > 0) {
    const username = email.slice(0, atIndex)
    const domain = email.slice(atIndex)
    
    if (username.length <= 2) {
      return `${username[0]}*${domain}`
    } else {
      return `${username[0]}${'*'.repeat(username.length - 2)}${username[username.length - 1]}${domain}`
    }
  }
  
  return email
}

/**
 * 截断文本
 * @param text 文本
 * @param maxLength 最大长度
 * @param suffix 后缀，默认为'...'
 * @returns 截断后的文本
 */
export function truncateText(text: string | null | undefined, maxLength: number, suffix: string = '...'): string {
  if (!text) {
    return '-'
  }
  
  if (text.length <= maxLength) {
    return text
  }
  
  return text.slice(0, maxLength - suffix.length) + suffix
}

/**
 * 格式化状态
 * @param status 状态值
 * @param statusMap 状态映射表
 * @returns 格式化后的状态文本
 */
export function formatStatus(status: string | number | null | undefined, statusMap: Record<string | number, string>): string {
  if (status === null || status === undefined) {
    return '-'
  }
  
  return statusMap[status] || String(status)
}

/**
 * 格式化数组为字符串
 * @param array 数组
 * @param separator 分隔符，默认为', '
 * @returns 格式化后的字符串
 */
export function formatArray(array: any[] | null | undefined, separator: string = ', '): string {
  if (!array || !Array.isArray(array) || array.length === 0) {
    return '-'
  }
  
  return array.join(separator)
}

/**
 * 格式化布尔值
 * @param value 布尔值
 * @param trueText 真值文本，默认为'是'
 * @param falseText 假值文本，默认为'否'
 * @returns 格式化后的文本
 */
export function formatBoolean(value: boolean | null | undefined, trueText: string = '是', falseText: string = '否'): string {
  if (value === null || value === undefined) {
    return '-'
  }
  
  return value ? trueText : falseText
}
